{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.linear_model import LinearRegression, LogisticRegression, SGDRegressor\n",
    "import random\n",
    "linear = LinearRegression()\n",
    "logis = LogisticRegression()\n",
    "sgd = SGDRegressor(max_iter=1500000, learning_rate=\"constant\", eta0=0.00015)\n",
    "\n",
    "\n",
    "\n",
    "def fileToTrainDataSet(filepath):\n",
    "    df=pd.read_table(\"dataForTrainingLinear.txt\", delimiter=\" \",header=None)\n",
    "    df.columns = [\"square\", \"distance\", \"price\"]\n",
    "    linear_x_train = df.loc[:, \"square\":\"distance\"]\n",
    "    linear_y_train = df.loc[:, \"price\"]\n",
    "    return (linear_x_train, linear_y_train)\n",
    "\n",
    "def fileToTrainDataSet2(filepath):\n",
    "    df=pd.read_table(filepath, delimiter=\" \",header=None)\n",
    "    df.columns = [0,1,2,3,4,5,6]\n",
    "    linear_x_train = df.loc[:, 0:5]\n",
    "    linear_y_train = df.loc[:, 6]\n",
    "    return (linear_x_train, linear_y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, y_train = fileToTrainDataSet(\"dataForTrainingLinear.txt\")\n",
    "x_test, y_test = fileToTrainDataSet(\"dataForTestingLinear.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SGDRegressor(alpha=0.0001, average=False, early_stopping=False, epsilon=0.1,\n",
       "             eta0=0.00015, fit_intercept=True, l1_ratio=0.15,\n",
       "             learning_rate='constant', loss='squared_loss', max_iter=1500000,\n",
       "             n_iter_no_change=5, penalty='l2', power_t=0.25, random_state=None,\n",
       "             shuffle=True, tol=0.001, validation_fraction=0.1, verbose=0,\n",
       "             warm_start=False)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd.fit(x_train, y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.17880194757683232"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd.score(x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 4.95846725 -9.88422639]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([-0.00948117])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(sgd.coef_)\n",
    "sgd.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def compute_error(theta0, theta1, theta2, x_data, y_data):\n",
    "    totalError = 0\n",
    "    for i in range(0, len(x_data)):\n",
    "        totalError += (y_data[i] - (theta1 * x_data[i, 0] + theta2 * x_data[i, 1] + theta0)) ** 2\n",
    "    return totalError / float(len(x_data))\n",
    "\n",
    "\n",
    "def gradient_descent_runner(x_data, y_data, theta0, theta1, theta2, lr, epochs):\n",
    "    # 计算总数据量\n",
    "    m = float(len(x_data))\n",
    "    \n",
    "    err_list = []\n",
    "    re_list = []\n",
    "    \n",
    "    for i in range(epochs):\n",
    "        theta0_grad = 0\n",
    "        theta1_grad = 0\n",
    "        theta2_grad = 0\n",
    "        # 计算梯度的总和再求平均\n",
    "        \n",
    "        if i % 10000 == 0:\n",
    "            err_list.append(i)\n",
    "            re_list.append(compute_error(theta0,theta1,theta2, x_data, y_data))\n",
    "        \n",
    "        \n",
    "        for j in range(0, len(x_data)):\n",
    "            theta0_grad += -(1/m) * (y_data[j] - (theta1 * x_data[j, 0] + theta2*x_data[j, 1] + theta0))\n",
    "            theta1_grad += -(1 / m) * x_data[j, 0] * (y_data[j] - (theta1 * x_data[j, 0] + theta2 * x_data[j, 1] + theta0))\n",
    "            theta2_grad += -(1 / m) * x_data[j, 1] * (y_data[j] - (theta1 * x_data[j, 0] + theta2 * x_data[j, 1] + theta0))\n",
    "        #更新b和k\n",
    "        theta0 = theta0 - (lr*theta0_grad)\n",
    "        theta1 = theta1 - (lr*theta1_grad)\n",
    "        theta2 = theta2 - (lr*theta2_grad)\n",
    "    return theta0, theta1, theta2,err_list, re_list\n",
    "\n",
    "def random_gradient_descent_runner(x_data, y_data, theta0, theta1, theta2, lr, epochs):\n",
    "    # 计算总数据量\n",
    "    m = float(len(x_data))\n",
    "    \n",
    "    err_list = []\n",
    "    re_list = []\n",
    "    \n",
    "    for i in range(epochs):\n",
    "        theta0_grad = 0\n",
    "        theta1_grad = 0\n",
    "        theta2_grad = 0\n",
    "        # 计算梯度的总和再求平均\n",
    "        \n",
    "        if i % 100000 == 0:\n",
    "            err_list.append(i)\n",
    "            re_list.append(compute_error(theta0,theta1,theta2, x_data, y_data))\n",
    "        \n",
    "        \n",
    "        \n",
    "        j = random.randint(0,len(x_data)-1)\n",
    "        theta0_grad += -(1/m) * (y_data[j] - (theta1 * x_data[j, 0] + theta2*x_data[j, 1] + theta0))\n",
    "        theta1_grad += -(1 / m) * x_data[j, 0] * (y_data[j] - (theta1 * x_data[j, 0] + theta2 * x_data[j, 1] + theta0))\n",
    "        theta2_grad += -(1 / m) * x_data[j, 1] * (y_data[j] - (theta1 * x_data[j, 0] + theta2 * x_data[j, 1] + theta0))\n",
    "        #更新b和k\n",
    "        theta0 = theta0 - (lr*theta0_grad)\n",
    "        theta1 = theta1 - (lr*theta1_grad)\n",
    "        theta2 = theta2 - (lr*theta2_grad)\n",
    "    return theta0, theta1, theta2,err_list, re_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 50.9 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "x_arr = []\n",
    "y_arr = []\n",
    "for i in range(0,4000000, 100000):\n",
    "    t0,t1,t2,x,y=random_gradient_descent_runner(x_train.values, y_train.values, 0,0,0,0.00018, 200000)\n",
    "    x_arr.append(i)\n",
    "    y_arr.append(y[-1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1250199.2768916988,\n",
       " 49811245031.08894,\n",
       " 3918822.0396692995,\n",
       " 7090252837711159.0,\n",
       " 696472091.4461478,\n",
       " 8561592.911565544,\n",
       " 2053163.2135790898,\n",
       " 1.0198775228202476e+18,\n",
       " 957.9598530801643,\n",
       " 3285892435354000.5,\n",
       " 6875052194536.124,\n",
       " 6377122347172.769,\n",
       " 14169641587.574898,\n",
       " 108812810039218.52,\n",
       " 24978.69264463598,\n",
       " 2.0486583516313895e+25,\n",
       " 93795568022.8086,\n",
       " 60202077.34842979,\n",
       " 1.9195031608312988e+21,\n",
       " 2226.8408268932485,\n",
       " 24537833.284481674,\n",
       " 51151337.8821079,\n",
       " 104455735926.78918,\n",
       " 4704762472872.433,\n",
       " 95566131748259.66,\n",
       " 19633747431547.89,\n",
       " 38691.41326428417,\n",
       " 2162163393.8162484,\n",
       " 605844700775914.4,\n",
       " 2749976528760691.0,\n",
       " 2113997878183.7024,\n",
       " 2376.638554278117,\n",
       " 2087.7621892060165,\n",
       " 1115.7837355366162,\n",
       " 420293174.1940289,\n",
       " 1345657232.226659,\n",
       " 74085830.99664178,\n",
       " 1.2958358813665158e+22,\n",
       " 7.486391963955401e+23,\n",
       " 2.4006985287288744e+16]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "y_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x132d3754400>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "#解决中文显示问题\n",
    "plt.rcParams['font.sans-serif'] = ['simHei'] # 指定默认字体\n",
    "plt.rcParams['axes.unicode_minus'] = False # 解决保存图像是负号'-'显示为方块的问题\n",
    "plt.xlabel(\"迭代次数\", fontdict={'size': 16})\n",
    "plt.ylabel(\"误差\",fontdict={\"size\":16})\n",
    "plt.title(\"学习率为0.00018的误差值\", fontdict={'size': 20})\n",
    "plt.xticks(x_arr)\n",
    "\n",
    "plt.rcParams['figure.figsize'] = (30.0, 12.0) # 单位是inches\n",
    "plt.scatter(x_arr,y_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "#逻辑回归\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, y_train = fileToTrainDataSet2(\"dataForTrainingLogistic.txt\")\n",
    "x_test, y_test = fileToTrainDataSet2(\"dataForTestingLogistic.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def compute_error(theta0, theta1, theta2, x_data, y_data):\n",
    "    totalError = 0\n",
    "    for i in range(0, len(x_data)):\n",
    "        totalError += (y_data[i] - (theta1 * x_data[i, 0] + theta2 * x_data[i, 1] + theta0)) ** 2\n",
    "    return totalError / float(len(x_data))\n",
    "\n",
    "\n",
    "def gradient_runner(x_data, y_data, thetas, lr, epochs):\n",
    "    # 计算总数据量\n",
    "    m = float(len(x_data))\n",
    "    \n",
    "    obj_vals = []\n",
    "    iter_vals= []    \n",
    "    for i in range(epochs):\n",
    "        \n",
    "        theta_grads = [0 for i in range(len(thetas))]\n",
    "        # 计算梯度的总和再求平均\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        for j in range(0, len(x_data)):\n",
    "            \n",
    "            linear_sum = thetas[0]\n",
    "            for k in range(len(thetas) - 1):\n",
    "                linear_sum += thetas[k + 1] * x_data[j,k]\n",
    "            hx = 1/(1+(math.exp(-1 * linear_sum)))\n",
    "                \n",
    "            theta_grads[0] += -(1/m) * (y_data[j] - hx)\n",
    "            theta_grads[1] += -(1/m) * (y_data[j] - hx) * x_data[j,0]\n",
    "            theta_grads[2] += -(1/m) * (y_data[j] - hx) * x_data[j,1]\n",
    "            theta_grads[3] += -(1/m) * (y_data[j] - hx) * x_data[j,2]\n",
    "            theta_grads[4] += -(1/m) * (y_data[j] - hx) * x_data[j,3]\n",
    "            theta_grads[5] += -(1/m) * (y_data[j] - hx) * x_data[j,4]\n",
    "            theta_grads[6] += -(1/m) * (y_data[j] - hx) * x_data[j,5]\n",
    "                    \n",
    "            \n",
    "          \n",
    "        for k in range(len(thetas)):\n",
    "            thetas[k] = thetas[k] - (lr * theta_grads[k])\n",
    "        \n",
    "        if i % 1000 == 0:\n",
    "            obj_val = 0\n",
    "            for j in range(0,len(x_data)):\n",
    "                linear_sum = thetas[0]\n",
    "                for k in range(len(thetas) - 1):\n",
    "                    linear_sum += thetas[k + 1] * x_data[j,k]\n",
    "                hx = 1/(1+(math.exp(-1 * linear_sum)))\n",
    "\n",
    "                obj_val += y_data[j] * math.log(hx)+(1-y_data[j]) * math.log(1-hx)\n",
    "            obj_vals.append(obj_val)\n",
    "            iter_vals.append(i)\n",
    "        \n",
    "    return thetas,obj_vals,iter_vals\n",
    "\n",
    "def predict(x_data, y_data,thetas):\n",
    "    # 计算总数据量\n",
    "    m = float(len(x_data))\n",
    "    \n",
    "   \n",
    "    re_list = []\n",
    "    \n",
    "    for j in range(0, len(x_data)):\n",
    "            \n",
    "            linear_sum = thetas[0]\n",
    "            for k in range(len(thetas) - 1):\n",
    "                linear_sum += thetas[k + 1] * x_data[j,k]\n",
    "            hx = 1/(1+(math.exp(-1 * linear_sum)))\n",
    "                \n",
    "            if hx > 0.5:\n",
    "                re_list.append(1)\n",
    "            else:\n",
    "                re_list.append(0)\n",
    "    return re_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "thetas, y,x = gradient_runner(x_train.values, y_train.values, [0,0,0,0,0,0,0],0.002, 20000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 1]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_score = predict(x_test.values, 0,[0.36351947988627764,\n",
    "  -1.6852297594214287,\n",
    "  2.2415283582023338,\n",
    "  -1.7023145525369483,\n",
    "  2.1984876093027808,\n",
    "  -1.4257324449801754,\n",
    "  0.014884683728058101])\n",
    "\n",
    "y_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0     0\n",
       " 1     0\n",
       " 2     0\n",
       " 3     1\n",
       " 4     0\n",
       "      ..\n",
       " 95    0\n",
       " 96    0\n",
       " 97    0\n",
       " 98    1\n",
       " 99    1\n",
       " Name: 6, Length: 100, dtype: int64, 0      1\n",
       " 1      1\n",
       " 2      1\n",
       " 3      1\n",
       " 4      0\n",
       "       ..\n",
       " 395    1\n",
       " 396    1\n",
       " 397    0\n",
       " 398    1\n",
       " 399    0\n",
       " Name: 6, Length: 400, dtype: int64)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test,y_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(y_test)):\n",
    "    if y_test[i] != y_score[i]:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x132d74a5a90>"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "#解决中文显示问题\n",
    "plt.rcParams['font.sans-serif'] = ['simHei'] # 指定默认字体\n",
    "plt.rcParams['axes.unicode_minus'] = False # 解决保存图像是负号'-'显示为方块的问题\n",
    "plt.xlabel(\"迭代次数\", fontdict={'size': 16})\n",
    "plt.ylabel(\"目标函数值\",fontdict={\"size\":16})\n",
    "plt.title(\"目标函数值变化\", fontdict={'size': 20})\n",
    "plt.xticks(x)\n",
    "\n",
    "plt.rcParams['figure.figsize'] = (30.0, 12.0) # 单位是inches\n",
    "plt.scatter(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "sizes = range(10,400,10)\n",
    "\n",
    "test_err = []\n",
    "train_err = []\n",
    "\n",
    "def err_check(err_list, arr1, arr2):\n",
    "    count = 0\n",
    "    for i in range(len(arr1)):\n",
    "        if (arr1[i] != arr2[i]):\n",
    "            count += 1\n",
    "    err_list.append(count)\n",
    "    \n",
    "for i in sizes:\n",
    "    x_train_size = x_train.sample(i)\n",
    "    y_train_size = y_train[x_train_size.index]\n",
    "    \n",
    "    thetas, y,x = gradient_runner(x_train_size.values, y_train_size.values,[0,0,0,0,0,0,0],0.002, 200)\n",
    "    y_test_pre = predict(x_test.values, 0, thetas)\n",
    "    \n",
    "    \n",
    "    \n",
    "    err_check(test_err, y_test_pre, y_test.values)\n",
    "    \n",
    "    \n",
    "    \n",
    "    x_train_size = x_train.sample(i)\n",
    "    y_train_size = y_train[x_train_size.index]\n",
    "    y_train_pre = predict(x_train_size.values, 0, thetas)\n",
    "\n",
    "    err_check(train_err, y_train_pre, y_train_size.values)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "39"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(test_err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0]"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_err"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x132d41c8c88>"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "k = range(10,400,10)\n",
    "plt.plot(k, train_err, color=\"red\",marker = \"o\")\n",
    "plt.plot(k, test_err, color=\"blue\", marker=\"o\")\n",
    "plt.legend([\"Training Dataset\", \"Testing Dataset\"])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
